const { Jimp } = require('jimp');
const axios = require('axios');

/**
 * 提取图片的主色调（优化算法）
 * @param {string} imageUrl - 图片URL或本地路径
 * @returns {Promise<string>} 主色调的HEX值（如 #FF5733）
 */
async function extractDominantColor(imageUrl) {
    try {
        // 读取图片（支持URL和本地路径）
        const image = await Jimp.read(imageUrl);
        const width = image.bitmap.width;
        const height = image.bitmap.height;

        // 颜色统计数组 [{color, count, saturation, weight}]
        const colorStats = new Map();

        // 采样间隔（每15个像素采样一次）
        const step = 15;

        // 计算图片中心区域（用于权重计算）
        const centerX = width / 2;
        const centerY = height / 2;
        const maxDistance = Math.sqrt(centerX * centerX + centerY * centerY);

        for (let y = 0; y < height; y += step) {
            for (let x = 0; x < width; x += step) {
                const color = image.getPixelColor(x, y);

                // 使用位运算解析RGBA值
                const r = (color >> 24) & 0xFF;
                const g = (color >> 16) & 0xFF;
                const b = (color >> 8) & 0xFF;
                const a = color & 0xFF;

                // 跳过透明像素
                if (a < 128) continue;

                // 跳过接近白色的像素（背景）
                if (r > 235 && g > 235 && b > 235) continue;

                // 跳过接近黑色的像素（文字/边框）
                if (r < 20 && g < 20 && b < 20) continue;

                // 跳过饱和度很低的灰色像素
                const maxRGB = Math.max(r, g, b);
                const minRGB = Math.min(r, g, b);
                const saturation = maxRGB === 0 ? 0 : (maxRGB - minRGB) / maxRGB;

                // 过滤饱和度太低的颜色（灰色调）
                if (saturation < 0.15) continue;

                // 计算位置权重（中心区域权重更高）
                const dx = x - centerX;
                const dy = y - centerY;
                const distance = Math.sqrt(dx * dx + dy * dy);
                const positionWeight = 1 + (1 - distance / maxDistance) * 0.5; // 1.0 ~ 1.5

                // 颜色量化：减少到32色阶（更细腻）
                // 使用 Math.min 确保量化后的值不超过 255
                const quantizedR = Math.min(255, Math.round(r / 8) * 8);
                const quantizedG = Math.min(255, Math.round(g / 8) * 8);
                const quantizedB = Math.min(255, Math.round(b / 8) * 8);

                // 转换为HEX
                const hexColor = rgbToHex(quantizedR, quantizedG, quantizedB);

                // 统计颜色（带权重）
                if (!colorStats.has(hexColor)) {
                    colorStats.set(hexColor, {
                        r: quantizedR,
                        g: quantizedG,
                        b: quantizedB,
                        count: 0,
                        weightedCount: 0,
                        saturation: saturation
                    });
                }

                const stats = colorStats.get(hexColor);
                stats.count += 1;
                stats.weightedCount += positionWeight;
            }
        }

        // 如果没有找到有效颜色，返回默认灰色
        if (colorStats.size === 0) {
            console.log('⚠️ 未检测到有效颜色，使用默认值');
            return { color1: '#E5E5E5', color2: null };
        }

        // 综合评分：权重计数 * 饱和度，排序找出前两个主色调
        const sortedColors = Array.from(colorStats.entries())
            .map(([hexColor, stats]) => ({
                color: hexColor,
                score: stats.weightedCount * (1 + stats.saturation),
                stats: stats
            }))
            .sort((a, b) => b.score - a.score);

        // 返回前两个主色调
        const color1 = sortedColors[0].color;
        const color2 = sortedColors.length > 1 ? sortedColors[1].color : null;

        console.log(`✅ 主色调提取成功: ${color1} (加权:${sortedColors[0].stats.weightedCount.toFixed(1)}, 饱和度:${(sortedColors[0].stats.saturation * 100).toFixed(1)}%)`);
        if (color2) {
            console.log(`   次色调: ${color2} (加权:${sortedColors[1].stats.weightedCount.toFixed(1)}, 饱和度:${(sortedColors[1].stats.saturation * 100).toFixed(1)}%)`);
        }
        console.log(`   共${colorStats.size}种颜色`);

        return { color1, color2 };

    } catch (error) {
        console.error('❌ 主色调提取失败:', error.message);
        // 失败时返回null，由调用方决定如何处理
        return null;
    }
}

/**
 * RGB转HEX
 * @param {number} r - Red (0-255)
 * @param {number} g - Green (0-255)
 * @param {number} b - Blue (0-255)
 * @returns {string} HEX颜色值（如 #FF5733）
 */
function rgbToHex(r, g, b) {
    // 确保RGB值在有效范围内（0-255）
    const clamp = (val) => Math.max(0, Math.min(255, Math.round(val)));

    return '#' + [r, g, b]
        .map(x => {
            const clamped = clamp(x);
            const hex = clamped.toString(16);
            return hex.length === 1 ? '0' + hex : hex;
        })
        .join('')
        .toUpperCase();
}

/**
 * 调整颜色亮度，使其适合作为背景色
 * @param {string} hexColor - HEX颜色值
 * @param {number} factor - 亮度因子 (0-1: 变暗, >1: 变亮)
 * @returns {string} 调整后的HEX颜色
 */
function adjustBrightness(hexColor, factor = 1.5) {
    // 移除#号
    const hex = hexColor.replace('#', '');

    // 转换为RGB
    const r = parseInt(hex.substring(0, 2), 16);
    const g = parseInt(hex.substring(2, 4), 16);
    const b = parseInt(hex.substring(4, 6), 16);

    // 调整亮度
    const newR = Math.min(255, Math.round(r + (255 - r) * (factor - 1)));
    const newG = Math.min(255, Math.round(g + (255 - g) * (factor - 1)));
    const newB = Math.min(255, Math.round(b + (255 - b) * (factor - 1)));

    return rgbToHex(newR, newG, newB);
}

module.exports = {
    extractDominantColor,
    rgbToHex,
    adjustBrightness
};
